home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / python2.6 / dist-packages / Alacarte / MainWindow.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  24.3 KB  |  695 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import gtk
  5. import gtk.glade as gtk
  6. import gmenu
  7. import gobject
  8. import gio
  9. import cgi
  10. import os
  11. import gettext
  12. import subprocess
  13. import urllib
  14.  
  15. try:
  16.     from Alacarte import config
  17.     gettext.bindtextdomain('alacarte', config.localedir)
  18.     gettext.textdomain('alacarte')
  19.     gtk.glade.bindtextdomain('alacarte', config.localedir)
  20. except:
  21.     pass
  22.  
  23. gtk.glade.textdomain('alacarte')
  24. _ = gettext.gettext
  25. from Alacarte.MenuEditor import MenuEditor
  26. from Alacarte import util
  27.  
  28. class MainWindow:
  29.     timer = None
  30.     allow_update = True
  31.     dnd_items = [
  32.         ('ALACARTE_ITEM_ROW', gtk.TARGET_SAME_APP, 0),
  33.         ('text/plain', 0, 1)]
  34.     dnd_menus = [
  35.         ('ALACARTE_MENU_ROW', gtk.TARGET_SAME_APP, 0)]
  36.     dnd_both = [
  37.         dnd_items[0]] + dnd_menus
  38.     drag_data = None
  39.     edit_pool = []
  40.     
  41.     def __init__(self, datadir, version, argv):
  42.         self.file_path = datadir
  43.         self.version = version
  44.         self.editor = MenuEditor()
  45.         gtk.window_set_default_icon_name('alacarte')
  46.         self.tree = gtk.glade.XML(os.path.join(self.file_path, 'alacarte.glade'))
  47.         signals = { }
  48.         for attr in dir(self):
  49.             signals[attr] = getattr(self, attr)
  50.         
  51.         self.tree.signal_autoconnect(signals)
  52.         self.setupMenuTree()
  53.         self.setupItemTree()
  54.         self.tree.get_widget('edit_delete').set_sensitive(False)
  55.         self.tree.get_widget('edit_revert_to_original').set_sensitive(False)
  56.         self.tree.get_widget('edit_properties').set_sensitive(False)
  57.         self.tree.get_widget('move_up_button').set_sensitive(False)
  58.         self.tree.get_widget('move_down_button').set_sensitive(False)
  59.         self.tree.get_widget('new_separator_button').set_sensitive(False)
  60.         accelgroup = gtk.AccelGroup()
  61.         (keyval, modifier) = gtk.accelerator_parse('<Ctrl>Z')
  62.         accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_mainwindow_undo)
  63.         (keyval, modifier) = gtk.accelerator_parse('<Ctrl><Shift>Z')
  64.         accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_mainwindow_redo)
  65.         (keyval, modifier) = gtk.accelerator_parse('F1')
  66.         accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_help_button_clicked)
  67.         self.tree.get_widget('mainwindow').add_accel_group(accelgroup)
  68.  
  69.     
  70.     def run(self):
  71.         self.loadMenus()
  72.         self.editor.applications.tree.add_monitor(self.menuChanged, None)
  73.         self.editor.settings.tree.add_monitor(self.menuChanged, None)
  74.         self.tree.get_widget('mainwindow').show_all()
  75.         gtk.main()
  76.  
  77.     
  78.     def menuChanged(self, *a):
  79.         if self.timer:
  80.             gobject.source_remove(self.timer)
  81.             self.timer = None
  82.         
  83.         self.timer = gobject.timeout_add(3, self.loadUpdates)
  84.  
  85.     
  86.     def loadUpdates(self):
  87.         if not self.allow_update:
  88.             return False
  89.         menu_tree = self.tree.get_widget('menu_tree')
  90.         item_tree = self.tree.get_widget('item_tree')
  91.         (items, iter) = item_tree.get_selection().get_selected()
  92.         update_items = False
  93.         (item_id, separator_path) = (None, None)
  94.         if iter:
  95.             update_items = True
  96.             if items[iter][3].get_type() == gmenu.TYPE_DIRECTORY:
  97.                 item_id = os.path.split(items[iter][3].get_desktop_file_path())[1]
  98.                 update_items = True
  99.             elif items[iter][3].get_type() == gmenu.TYPE_ENTRY:
  100.                 item_id = items[iter][3].get_desktop_file_id()
  101.                 update_items = True
  102.             elif items[iter][3].get_type() == gmenu.TYPE_SEPARATOR:
  103.                 item_id = items.get_path(iter)
  104.                 update_items = True
  105.             
  106.         
  107.         (menus, iter) = menu_tree.get_selection().get_selected()
  108.         update_menus = False
  109.         menu_id = None
  110.         if iter:
  111.             if menus[iter][2].get_desktop_file_path():
  112.                 menu_id = os.path.split(menus[iter][2].get_desktop_file_path())[1]
  113.             else:
  114.                 menu_id = menus[iter][2].get_menu_id()
  115.             update_menus = True
  116.         
  117.         self.loadMenus()
  118.         if update_menus:
  119.             menu_tree.get_model().foreach(self.findMenu, menu_id)
  120.             (menus, iter) = menu_tree.get_selection().get_selected()
  121.             if iter:
  122.                 self.on_menu_tree_cursor_changed(menu_tree)
  123.             
  124.         
  125.         if update_items:
  126.             i = 0
  127.             for item in item_tree.get_model():
  128.                 found = False
  129.                 if item[3].get_type() == gmenu.TYPE_ENTRY and item[3].get_desktop_file_id() == item_id:
  130.                     found = True
  131.                 
  132.                 if item[3].get_type() == gmenu.TYPE_DIRECTORY and item[3].get_desktop_file_path():
  133.                     if os.path.split(item[3].get_desktop_file_path())[1] == item_id:
  134.                         found = True
  135.                     
  136.                 
  137.                 if item[3].get_type() == gmenu.TYPE_SEPARATOR:
  138.                     if not isinstance(item_id, tuple):
  139.                         continue
  140.                     
  141.                     if (item_id[0] - 1,) == (i,):
  142.                         found = True
  143.                     elif (item_id[0] + 1,) == (i,):
  144.                         found = True
  145.                     elif (item_id[0],) == (i,):
  146.                         found = True
  147.                     
  148.                 
  149.                 if found:
  150.                     item_tree.get_selection().select_path((i,))
  151.                     self.on_item_tree_cursor_changed(item_tree)
  152.                     break
  153.                 
  154.                 i += 1
  155.             
  156.         
  157.         return False
  158.  
  159.     
  160.     def findMenu(self, menus, path, iter, menu_id):
  161.         if not menus[path][2].get_desktop_file_path():
  162.             if menu_id == menus[path][2].get_menu_id():
  163.                 menu_tree = self.tree.get_widget('menu_tree')
  164.                 menu_tree.expand_to_path(path)
  165.                 menu_tree.get_selection().select_path(path)
  166.                 return True
  167.             return False
  168.         if os.path.split(menus[path][2].get_desktop_file_path())[1] == menu_id:
  169.             menu_tree = self.tree.get_widget('menu_tree')
  170.             menu_tree.expand_to_path(path)
  171.             menu_tree.get_selection().select_path(path)
  172.             return True
  173.  
  174.     
  175.     def setupMenuTree(self):
  176.         self.menu_store = gtk.TreeStore(gtk.gdk.Pixbuf, str, object)
  177.         menus = self.tree.get_widget('menu_tree')
  178.         column = gtk.TreeViewColumn(_('Name'))
  179.         column.set_spacing(4)
  180.         cell = gtk.CellRendererPixbuf()
  181.         column.pack_start(cell, False)
  182.         column.set_attributes(cell, pixbuf = 0)
  183.         cell = gtk.CellRendererText()
  184.         cell.set_fixed_size(-1, 25)
  185.         column.pack_start(cell, True)
  186.         column.set_attributes(cell, markup = 1)
  187.         column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
  188.         menus.append_column(column)
  189.         menus.enable_model_drag_source(gtk.gdk.BUTTON1_MASK, self.dnd_menus, gtk.gdk.ACTION_COPY)
  190.         menus.enable_model_drag_dest(self.dnd_both, gtk.gdk.ACTION_PRIVATE)
  191.  
  192.     
  193.     def setupItemTree(self):
  194.         items = self.tree.get_widget('item_tree')
  195.         column = gtk.TreeViewColumn(_('Show'))
  196.         cell = gtk.CellRendererToggle()
  197.         cell.connect('toggled', self.on_item_tree_show_toggled)
  198.         column.pack_start(cell, True)
  199.         column.set_attributes(cell, active = 0)
  200.         column.set_cell_data_func(cell, self._cell_data_toggle_func)
  201.         items.append_column(column)
  202.         column = gtk.TreeViewColumn(_('Item'))
  203.         column.set_spacing(4)
  204.         cell = gtk.CellRendererPixbuf()
  205.         column.pack_start(cell, False)
  206.         column.set_attributes(cell, pixbuf = 1)
  207.         cell = gtk.CellRendererText()
  208.         cell.set_fixed_size(-1, 25)
  209.         column.pack_start(cell, True)
  210.         column.set_attributes(cell, markup = 2)
  211.         items.append_column(column)
  212.         self.item_store = gtk.ListStore(bool, gtk.gdk.Pixbuf, str, object)
  213.         items.set_model(self.item_store)
  214.         items.enable_model_drag_source(gtk.gdk.BUTTON1_MASK, self.dnd_items, gtk.gdk.ACTION_COPY)
  215.         items.enable_model_drag_dest(self.dnd_items, gtk.gdk.ACTION_PRIVATE)
  216.  
  217.     
  218.     def _cell_data_toggle_func(self, tree_column, renderer, model, treeiter):
  219.         if model[treeiter][3].get_type() == gmenu.TYPE_SEPARATOR:
  220.             renderer.set_property('visible', False)
  221.         else:
  222.             renderer.set_property('visible', True)
  223.  
  224.     
  225.     def loadMenus(self):
  226.         self.menu_store.clear()
  227.         for menu in self.editor.getMenus():
  228.             iters = [
  229.                 None] * 20
  230.             self.loadMenu(iters, menu)
  231.         
  232.         menu_tree = self.tree.get_widget('menu_tree')
  233.         menu_tree.set_model(self.menu_store)
  234.         for menu in self.menu_store:
  235.             
  236.             try:
  237.                 menu_tree.expand_to_path(menu.path)
  238.             continue
  239.             continue
  240.  
  241.         
  242.         menu_tree.get_selection().select_path((0,))
  243.         self.on_menu_tree_cursor_changed(menu_tree)
  244.  
  245.     
  246.     def loadMenu(self, iters, parent, depth = 0):
  247.         if depth == 0:
  248.             icon = util.getIcon(parent)
  249.             iters[depth] = self.menu_store.append(None, (icon, cgi.escape(parent.get_name()), parent))
  250.         
  251.         depth += 1
  252.         for menu, show in self.editor.getMenus(parent):
  253.             if show:
  254.                 name = cgi.escape(menu.get_name())
  255.             else:
  256.                 name = '<small><i>' + cgi.escape(menu.get_name()) + '</i></small>'
  257.             icon = util.getIcon(menu)
  258.             iters[depth] = self.menu_store.append(iters[depth - 1], (icon, name, menu))
  259.             self.loadMenu(iters, menu, depth)
  260.         
  261.         depth -= 1
  262.  
  263.     
  264.     def loadItems(self, menu, menu_path):
  265.         self.item_store.clear()
  266.         for item, show in self.editor.getItems(menu):
  267.             menu_icon = None
  268.             if item.get_type() == gmenu.TYPE_SEPARATOR:
  269.                 name = '---'
  270.                 icon = None
  271.             elif show:
  272.                 name = cgi.escape(item.get_name())
  273.             else:
  274.                 name = '<small><i>' + cgi.escape(item.get_name()) + '</i></small>'
  275.             icon = util.getIcon(item)
  276.             self.item_store.append((show, icon, name, item))
  277.         
  278.  
  279.     
  280.     def waitForNewItemProcess(self, process, parent_id, file_path):
  281.         if process.poll() != None:
  282.             if os.path.isfile(file_path):
  283.                 self.editor.insertExternalItem(os.path.split(file_path)[1], parent_id)
  284.             
  285.             return False
  286.         return True
  287.  
  288.     
  289.     def waitForNewMenuProcess(self, process, parent_id, file_path):
  290.         if process.poll() != None:
  291.             broken_path = os.path.join(os.path.split(file_path)[0], '.directory')
  292.             if os.path.isfile(broken_path):
  293.                 os.rename(broken_path, file_path)
  294.             
  295.             if os.path.isfile(file_path):
  296.                 self.editor.insertExternalMenu(os.path.split(file_path)[1], parent_id)
  297.             
  298.             return False
  299.         return True
  300.  
  301.     
  302.     def waitForEditProcess(self, process, file_path):
  303.         if process.poll() != None:
  304.             self.edit_pool.remove(file_path)
  305.             return False
  306.         return True
  307.  
  308.     
  309.     def on_new_menu_button_clicked(self, button):
  310.         menu_tree = self.tree.get_widget('menu_tree')
  311.         (menus, iter) = menu_tree.get_selection().get_selected()
  312.         if not iter:
  313.             parent = menus[(0,)][2]
  314.             menu_tree.expand_to_path((0,))
  315.             menu_tree.get_selection().select_path((0,))
  316.         else:
  317.             parent = menus[iter][2]
  318.         file_path = os.path.join(util.getUserDirectoryPath(), util.getUniqueFileId('alacarte-made', '.directory'))
  319.         process = subprocess.Popen([
  320.             'gnome-desktop-item-edit',
  321.             file_path], env = os.environ)
  322.         gobject.timeout_add(100, self.waitForNewMenuProcess, process, parent.menu_id, file_path)
  323.  
  324.     
  325.     def on_new_item_button_clicked(self, button):
  326.         menu_tree = self.tree.get_widget('menu_tree')
  327.         (menus, iter) = menu_tree.get_selection().get_selected()
  328.         if not iter:
  329.             parent = menus[(0,)][2]
  330.             menu_tree.expand_to_path((0,))
  331.             menu_tree.get_selection().select_path((0,))
  332.         else:
  333.             parent = menus[iter][2]
  334.         file_path = os.path.join(util.getUserItemPath(), util.getUniqueFileId('alacarte-made', '.desktop'))
  335.         process = subprocess.Popen([
  336.             'gnome-desktop-item-edit',
  337.             file_path], env = os.environ)
  338.         gobject.timeout_add(100, self.waitForNewItemProcess, process, parent.menu_id, file_path)
  339.  
  340.     
  341.     def on_new_separator_button_clicked(self, button):
  342.         item_tree = self.tree.get_widget('item_tree')
  343.         (items, iter) = item_tree.get_selection().get_selected()
  344.         if not iter:
  345.             return None
  346.         after = items[iter][3]
  347.         menu_tree = self.tree.get_widget('menu_tree')
  348.         (menus, iter) = menu_tree.get_selection().get_selected()
  349.         parent = menus[iter][2]
  350.         self.editor.createSeparator(parent, after = after)
  351.  
  352.     
  353.     def on_properties_button_clicked(self, button):
  354.         self.on_edit_properties_activate(None)
  355.  
  356.     
  357.     def on_delete_button_clicked(self, button):
  358.         self.on_edit_delete_activate(None)
  359.  
  360.     
  361.     def on_edit_delete_activate(self, menu):
  362.         item_tree = self.tree.get_widget('item_tree')
  363.         (items, iter) = item_tree.get_selection().get_selected()
  364.         if not iter:
  365.             return None
  366.         item = items[iter][3]
  367.         if item.get_type() == gmenu.TYPE_ENTRY:
  368.             self.editor.deleteItem(item)
  369.         elif item.get_type() == gmenu.TYPE_DIRECTORY:
  370.             self.editor.deleteMenu(item)
  371.         elif item.get_type() == gmenu.TYPE_SEPARATOR:
  372.             self.editor.deleteSeparator(item)
  373.         
  374.  
  375.     
  376.     def on_edit_revert_to_original_activate(self, menu):
  377.         item_tree = self.tree.get_widget('item_tree')
  378.         (items, iter) = item_tree.get_selection().get_selected()
  379.         if not iter:
  380.             return None
  381.         item = items[iter][3]
  382.         if item.get_type() == gmenu.TYPE_ENTRY:
  383.             self.editor.revertItem(item)
  384.         elif item.get_type() == gmenu.TYPE_DIRECTORY:
  385.             self.editor.revertMenu(item)
  386.         
  387.  
  388.     
  389.     def on_edit_properties_activate(self, menu):
  390.         item_tree = self.tree.get_widget('item_tree')
  391.         (items, iter) = item_tree.get_selection().get_selected()
  392.         if not iter:
  393.             return None
  394.         item = items[iter][3]
  395.         if item.get_type() not in (gmenu.TYPE_ENTRY, gmenu.TYPE_DIRECTORY):
  396.             return None
  397.         if item.get_type() == gmenu.TYPE_ENTRY:
  398.             file_path = os.path.join(util.getUserItemPath(), item.get_desktop_file_id())
  399.             file_type = 'Item'
  400.         elif item.get_type() == gmenu.TYPE_DIRECTORY:
  401.             if item.get_desktop_file_path() == None:
  402.                 file_path = util.getUniqueFileId('alacarte-made', '.directory')
  403.                 parser = util.DesktopParser(file_path, 'Directory')
  404.                 parser.set('Name', item.get_name())
  405.                 parser.set('Comment', item.get_comment())
  406.                 parser.set('Icon', item.get_icon())
  407.                 parser.write(open(file_path))
  408.             else:
  409.                 file_path = os.path.join(util.getUserDirectoryPath(), os.path.split(item.get_desktop_file_path())[1])
  410.             file_type = 'Menu'
  411.         
  412.         if not os.path.isfile(file_path):
  413.             data = open(item.get_desktop_file_path()).read()
  414.             open(file_path, 'w').write(data)
  415.             self.editor._MenuEditor__addUndo([
  416.                 (file_type, os.path.split(file_path)[1])])
  417.         else:
  418.             self.editor._MenuEditor__addUndo([
  419.                 item])
  420.         if file_path not in self.edit_pool:
  421.             self.edit_pool.append(file_path)
  422.             process = subprocess.Popen([
  423.                 'gnome-desktop-item-edit',
  424.                 file_path], env = os.environ)
  425.             gobject.timeout_add(100, self.waitForEditProcess, process, file_path)
  426.         
  427.  
  428.     
  429.     def on_menu_tree_cursor_changed(self, treeview):
  430.         (menus, iter) = treeview.get_selection().get_selected()
  431.         menu_path = menus.get_path(iter)
  432.         item_tree = self.tree.get_widget('item_tree')
  433.         item_tree.get_selection().unselect_all()
  434.         self.loadItems(self.menu_store[menu_path][2], menu_path)
  435.         self.tree.get_widget('edit_delete').set_sensitive(False)
  436.         self.tree.get_widget('edit_revert_to_original').set_sensitive(False)
  437.         self.tree.get_widget('edit_properties').set_sensitive(False)
  438.         self.tree.get_widget('move_up_button').set_sensitive(False)
  439.         self.tree.get_widget('move_down_button').set_sensitive(False)
  440.         self.tree.get_widget('new_separator_button').set_sensitive(False)
  441.  
  442.     
  443.     def on_menu_tree_drag_data_get(self, treeview, context, selection, target_id, etime):
  444.         (menus, iter) = treeview.get_selection().get_selected()
  445.         self.drag_data = menus[iter][2]
  446.  
  447.     
  448.     def on_menu_tree_drag_data_received(self, treeview, context, x, y, selection, info, etime):
  449.         menus = treeview.get_model()
  450.         drop_info = treeview.get_dest_row_at_pos(x, y)
  451.         if drop_info:
  452.             (path, position) = drop_info
  453.             types = (gtk.TREE_VIEW_DROP_INTO_OR_BEFORE, gtk.TREE_VIEW_DROP_INTO_OR_AFTER)
  454.             if position not in types:
  455.                 context.finish(False, False, etime)
  456.                 return False
  457.             if selection.target in ('ALACARTE_ITEM_ROW', 'ALACARTE_MENU_ROW'):
  458.                 if self.drag_data == None:
  459.                     return False
  460.                 item = self.drag_data
  461.                 new_parent = menus[path][2]
  462.                 treeview.get_selection().select_path(path)
  463.                 if item.get_type() == gmenu.TYPE_ENTRY:
  464.                     self.editor.copyItem(item, new_parent)
  465.                 elif item.get_type() == gmenu.TYPE_DIRECTORY:
  466.                     if self.editor.moveMenu(item, new_parent) == False:
  467.                         self.loadUpdates()
  468.                     
  469.                 else:
  470.                     context.finish(False, False, etime)
  471.                 context.finish(True, True, etime)
  472.             
  473.         
  474.         self.drag_data = None
  475.  
  476.     
  477.     def on_item_tree_show_toggled(self, cell, path):
  478.         item = self.item_store[path][3]
  479.         if item.get_type() == gmenu.TYPE_SEPARATOR:
  480.             return None
  481.         if self.item_store[path][0]:
  482.             self.editor.setVisible(item, False)
  483.         else:
  484.             self.editor.setVisible(item, True)
  485.         self.item_store[path][0] = not self.item_store[path][0]
  486.  
  487.     
  488.     def on_item_tree_cursor_changed(self, treeview):
  489.         (items, iter) = treeview.get_selection().get_selected()
  490.         if iter is None:
  491.             return None
  492.         item = items[iter][3]
  493.         self.tree.get_widget('edit_delete').set_sensitive(True)
  494.         self.tree.get_widget('new_separator_button').set_sensitive(True)
  495.         if self.editor.canRevert(item):
  496.             self.tree.get_widget('edit_revert_to_original').set_sensitive(True)
  497.         else:
  498.             self.tree.get_widget('edit_revert_to_original').set_sensitive(False)
  499.         if not item.get_type() == gmenu.TYPE_SEPARATOR:
  500.             self.tree.get_widget('edit_properties').set_sensitive(True)
  501.         else:
  502.             self.tree.get_widget('edit_properties').set_sensitive(False)
  503.         if items.get_path(iter)[0] == 0:
  504.             self.tree.get_widget('move_up_button').set_sensitive(False)
  505.         else:
  506.             self.tree.get_widget('move_up_button').set_sensitive(True)
  507.         if items.get_path(iter)[0] == len(items) - 1:
  508.             self.tree.get_widget('move_down_button').set_sensitive(False)
  509.         else:
  510.             self.tree.get_widget('move_down_button').set_sensitive(True)
  511.  
  512.     
  513.     def on_item_tree_row_activated(self, treeview, path, column):
  514.         self.on_edit_properties_activate(None)
  515.  
  516.     
  517.     def on_item_tree_popup_menu(self, item_tree, event = None):
  518.         (model, iter) = item_tree.get_selection().get_selected()
  519.         if event:
  520.             if event.button != 3:
  521.                 return None
  522.             button = event.button
  523.             event_time = event.time
  524.             info = item_tree.get_path_at_pos(int(event.x), int(event.y))
  525.             if info != None:
  526.                 (path, col, cellx, celly) = info
  527.                 item_tree.grab_focus()
  528.                 item_tree.set_cursor(path, col, 0)
  529.             
  530.         else:
  531.             path = model.get_path(iter)
  532.             button = 0
  533.             event_time = 0
  534.             item_tree.grab_focus()
  535.             item_tree.set_cursor(path, item_tree.get_columns()[0], 0)
  536.         popup = self.tree.get_widget('edit_menu')
  537.         popup.popup(None, None, None, button, event_time)
  538.         return True
  539.  
  540.     
  541.     def on_item_tree_drag_data_get(self, treeview, context, selection, target_id, etime):
  542.         (items, iter) = treeview.get_selection().get_selected()
  543.         self.drag_data = items[iter][3]
  544.  
  545.     
  546.     def on_item_tree_drag_data_received(self, treeview, context, x, y, selection, info, etime):
  547.         items = treeview.get_model()
  548.         types = (gtk.TREE_VIEW_DROP_BEFORE, gtk.TREE_VIEW_DROP_INTO_OR_BEFORE)
  549.         if selection.target == 'ALACARTE_ITEM_ROW':
  550.             drop_info = treeview.get_dest_row_at_pos(x, y)
  551.             before = None
  552.             after = None
  553.             if self.drag_data == None:
  554.                 return False
  555.             item = self.drag_data
  556.             if drop_info:
  557.                 (path, position) = drop_info
  558.                 if position in types:
  559.                     before = items[path][3]
  560.                 else:
  561.                     after = items[path][3]
  562.             else:
  563.                 path = (len(items) - 1,)
  564.                 after = items[path][3]
  565.             if item.get_type() == gmenu.TYPE_ENTRY:
  566.                 self.editor.moveItem(item, item.get_parent(), before, after)
  567.             elif item.get_type() == gmenu.TYPE_DIRECTORY:
  568.                 if self.editor.moveMenu(item, item.get_parent(), before, after) == False:
  569.                     self.loadUpdates()
  570.                 
  571.             elif item.get_type() == gmenu.TYPE_SEPARATOR:
  572.                 self.editor.moveSeparator(item, item.get_parent(), before, after)
  573.             
  574.             context.finish(True, True, etime)
  575.         elif selection.target == 'text/plain':
  576.             if selection.data == None:
  577.                 return False
  578.             (menus, iter) = self.tree.get_widget('menu_tree').get_selection().get_selected()
  579.             parent = menus[iter][2]
  580.             drop_info = treeview.get_dest_row_at_pos(x, y)
  581.             before = None
  582.             after = None
  583.             if drop_info:
  584.                 (path, position) = drop_info
  585.                 if position in types:
  586.                     before = items[path][3]
  587.                 else:
  588.                     after = items[path][3]
  589.             else:
  590.                 path = (len(items) - 1,)
  591.                 after = items[path][3]
  592.             file_path = urllib.unquote(selection.data).strip()
  593.             if not file_path.startswith('file:'):
  594.                 return None
  595.             myfile = gio.File(uri = file_path)
  596.             file_info = myfile.query_info(gio.FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE)
  597.             content_type = file_info.get_content_type()
  598.             if content_type == 'application/x-desktop':
  599.                 input_stream = myfile.read()
  600.                 open('/tmp/alacarte-dnd.desktop', 'w').write(input_stream.read())
  601.                 parser = util.DesktopParser('/tmp/alacarte-dnd.desktop')
  602.                 self.editor.createItem(parent, parser.get('Icon'), parser.get('Name', self.editor.locale), parser.get('Comment', self.editor.locale), parser.get('Exec'), parser.get('Terminal'), before, after)
  603.             elif content_type in ('application/x-shellscript', 'application/x-executable'):
  604.                 self.editor.createItem(parent, None, os.path.split(file_path)[1].strip(), None, file_path.replace('file://', '').strip(), False, before, after)
  605.             
  606.         
  607.         self.drag_data = None
  608.  
  609.     
  610.     def on_item_tree_key_press_event(self, item_tree, event):
  611.         if event.keyval == gtk.keysyms.Delete:
  612.             self.on_edit_delete_activate(item_tree)
  613.         
  614.  
  615.     
  616.     def on_move_up_button_clicked(self, button):
  617.         item_tree = self.tree.get_widget('item_tree')
  618.         (items, iter) = item_tree.get_selection().get_selected()
  619.         if not iter:
  620.             return None
  621.         path = items.get_path(iter)
  622.         if path[0] == 0:
  623.             return None
  624.         item = items[path][3]
  625.         before = items[(path[0] - 1,)][3]
  626.         if item.get_type() == gmenu.TYPE_ENTRY:
  627.             self.editor.moveItem(item, item.get_parent(), before = before)
  628.         elif item.get_type() == gmenu.TYPE_DIRECTORY:
  629.             self.editor.moveMenu(item, item.get_parent(), before = before)
  630.         elif item.get_type() == gmenu.TYPE_SEPARATOR:
  631.             self.editor.moveSeparator(item, item.get_parent(), before = before)
  632.         
  633.  
  634.     
  635.     def on_move_down_button_clicked(self, button):
  636.         item_tree = self.tree.get_widget('item_tree')
  637.         (items, iter) = item_tree.get_selection().get_selected()
  638.         if not iter:
  639.             return None
  640.         path = items.get_path(iter)
  641.         if path[0] == len(items) - 1:
  642.             return None
  643.         item = items[path][3]
  644.         after = items[path][3]
  645.         if item.get_type() == gmenu.TYPE_ENTRY:
  646.             self.editor.moveItem(item, item.get_parent(), after = after)
  647.         elif item.get_type() == gmenu.TYPE_DIRECTORY:
  648.             self.editor.moveMenu(item, item.get_parent(), after = after)
  649.         elif item.get_type() == gmenu.TYPE_SEPARATOR:
  650.             self.editor.moveSeparator(item, item.get_parent(), after = after)
  651.         
  652.  
  653.     
  654.     def on_mainwindow_undo(self, accelgroup, window, keyval, modifier):
  655.         self.editor.undo()
  656.  
  657.     
  658.     def on_mainwindow_redo(self, accelgroup, window, keyval, modifier):
  659.         self.editor.redo()
  660.  
  661.     
  662.     def on_help_button_clicked(self, *args):
  663.         gtk.show_uri(gtk.gdk.screen_get_default(), 'ghelp:user-guide#menu-editor', gtk.get_current_event_time())
  664.  
  665.     
  666.     def on_revert_button_clicked(self, button):
  667.         dialog = self.tree.get_widget('revertdialog')
  668.         dialog.set_transient_for(self.tree.get_widget('mainwindow'))
  669.         dialog.show_all()
  670.         if dialog.run() == gtk.RESPONSE_YES:
  671.             self.editor.revert()
  672.         
  673.         dialog.hide()
  674.  
  675.     
  676.     def on_close_button_clicked(self, button):
  677.         
  678.         try:
  679.             self.tree.get_widget('mainwindow').hide()
  680.         except:
  681.             pass
  682.  
  683.         gobject.timeout_add(10, self.quit)
  684.  
  685.     
  686.     def on_style_set(self, *args):
  687.         self.loadUpdates()
  688.  
  689.     
  690.     def quit(self):
  691.         self.editor.quit()
  692.         gtk.main_quit()
  693.  
  694.  
  695.